babl: improve log output on Android.

No need to log end of lines. This is not like a printf where we are
trying to pretty-print.

babl: replace a fprintf (stderr, ...) with babl_log().

It will make it visible in the logcat, for instance in Android Studio.
As a general rule, we should use babl_log() for anything which we
consider as "logs", unless we want to direct them to a given output for
sure (for instance in the case of CLI tools where we want the output to
be on standard I/O in terminal, fprintf() still is the best choice).

tests: make babl build on haiku

Using -lphtread instead of -pthread in Makefile.am fixes the build when using
gcc-x86 under haiku, figured out by schumaml.

babl/base: model-gray, avoid potential NaN

babl: add rendering intent argument to icc loading API

babl: abstract out TRC gamma detectors

babl: babl_log() implementation for Android.

babl: skip unknown formats when loading cache

Fixes bug #787467.

Formats based on custom primaries provided by applications are unknown to babl
at launch, we still want to keep the data though, since this list of most used
fishes first is useful resource in combination with the warnings about missing
fast paths.

babl: make utility file reading function non-static

babl: remove inlined implementation of powf

babl: replace trc lut inverter with binary search

Much faster and much more accurate.

babl: add icc meta-data extraction functions

Instead of extracting all meta-data of ICC profiles and attaching them to
BablSpaces, we provide an string key/value API to query meta data of in-memory
ICC profiles.

tools: add BablPolynomial test to trc-validator.c

babl: in BablTRC, use BablPolynomial to approximate gamma func.

Use BablPolynomial to approximate gamma functions of TRCs over the
(0, 1) range, for FORMULA_GAMMA and FORMULA_SRGB TRCs.

Use generic FORMULA_GAMMA TRCs for 1.8 and 2.2 gammas, instead of
specialized versions.

babl: add babl-polynomial.[hc]

Implements BablPolynomial, an opaque type representing a real valued
polynomial of a real variable.  Currently, exposes the following
functions:

  * babl_polynomial_eval():  Evaluates a polynomial.

  * babl_polynomial_approximate_gamma():  Calculates a polynomial
    approximation of a gamma function.

babl: further nan prevention in babl-trc

babl: in babl-trc.c, fix babl_powf()

babl: avoid accidental matrix overwrite by long names

.. by increasing the static per space allocation to 512 bytes, these names need
to become shorter - or the name be allocated dynamically. This fixes problems
with parameterized lab / sRGB like TRCs - which yielded really long names.

babl: protect some functions used by TRC code from NaNs

babl: actually reverse preceding change

restore segfault for massimo

@massimo: pretty please use git :)

It would be really nice if others, and prolifix people like
you, prepared git formatted patches, so that it is much saner
and easier to push and work with contributions as a maintainer
with a dirty tree, and in even more valuable bugs than this
one.. without needing to re-read and re-understand the entire
context of the fix, before fully reimplementing it.

This commit fixes bug #787441, where NaN is polluting the
computer error/tolerance.

extensions: finish API update

NEWS: aggregate news

update docs

extensions: follow change dropping long return

babl: drop long return from conversion funcs

They are propagated and instructions are spent on that, but their value are
never used. Some conversion functions in base even used the argument passed for
counting down to 0 and return 0 instead, to no ill effect.

Since we do not currently see external babl extensions, we can break extensions
API without bumping the library version, this is even a change where due to
varargs, old extensions will continue working until migrated.

babl: remove unused static linear luts for u8 rgb space converters

extensions: keep old algoritmic float in parallel with table

The newly introduced table isn't bit accurate with our reference,
the ~3x faster float 2 half conversion is available with a higher
tolerance.

extensions: fix type error in float 2 half

extensions: make float-half extension use exact LUTs

Both for conversion from half to float with a on load initialized table, and
with new tables an faster approach from qcms / mozilla / webkit.

babl: make more use of float matrices where appropriate

babl: trade gained fishing performance for better fish

babl: bail early on paths that are bad ideas

Not going through/bench-marking chains that will make the number of components
drop below the input/output counts, and not permitting a temporary lack of
alpha both fixes bugs at higher tolerances and speeds up path selection.

babl: add babl_fast_fish api

babl: add R'G'B' u8 color space convertors

babl: make TRCs internal API

babl: add Rec2020 space

babl: make matrix+trc space detector generic

babl: abstract space duplicate detection

tools: follow constness change in icc parsing error handling

babl: make error argument of babl_space_from_icc optional

babl: detect sRGB profiles from matrix

When TRCs also are matching, return internal sRGB instead of creating a
duplicate.

babl: indentation in trc

babl: move srgb detection to srgb_formula constructor

babl: fix overflow detection at end of luts

babl: implement interpolation for lut trcs

babl: icc implement ascii decoding of mluc

babl: add parametric handling for sRGB style TRCs (icc V4)

babl: use trcs own fun directly in early stages

tools: babl-icc-rewrite; abort with error message instead of segfault

babl: use babl_malloc instead of misgided use of aligned_alloc thinking it was like alloca

babl: use _aligned_malloc() instead of aligned_alloc() on Win32.

Thanks to Lionel N. for raising the issue. It was failing to build for
Windows with:
> babl/babl-space.c:503: undefined reference to `aligned_alloc'
Windows has apparently a similar API, except that the size and alignment
parameters are inverted.
See https://msdn.microsoft.com/library/8z34s9c6.aspx

babl-icc: add support for some ICCv4 profiles

RGB Matrix profiles with not too complex (or sRGB) parametric TRCs is what
should work fine.

babl: move RGB space conversion code to babl-space.c

babl: make trcs capable of iterating buffers

babl: do one SSE2 memory load per pixel for color matrix transform

babl: add sse2 acceleration for color transform

Many of the code paths are now duplicated, the duplication should decrease as
the SSE2/SIMD versions evolve further and stop resembling the code they were
cloned from.

babl: change MAX_BUFFER_SIZE to 512

This is the value that determins the smaller size big buffers are broken up in
and processed chunk-by chunk for multi-path conversions.

With tools/babl-benchmark for a particular workload and machine the following
results were attained, all values are in mb/s. There seem to be two sweet-spots
one around 128 and one around 512. Now using 512 which probably has better
cache behavior on most cpus than the old value 2048.

MAX_BUFFER_SIZE benchmarks,
    8:  437.1
   16:  458.8
   32:  495.0
   64:  482.6
   96:  496.4
  127:  508.8
  128:  514.2 506.7 495.1
  130:  494.6
  150:  479.5
  255:  492.2
  256:  491.0 486.8
  384:  500.8
  450:  503.7
  500:  499.6 496.5
  511:  477.8
  512:  511.0 508.7 500.6
  514:  499.3
  515:  504.7 502
  520:  512.9 491
  530:  501.8
  550:  483.3
  768:  493.0
 1024:  491.6
 2048:  489.5
 4096:  501.2
 8192:  499.0

babl: refactor matrix_mul_vector further towards SIMD

babl: register more RGB auto-converters for non-sRGB spaces

babl: use floating point version of srgb trc func

tools: add c program for validating TRC approximations

replace gamma approximations

babl: move trc functions inside babl-trc.c

Use lolremez 9 degree polynominal approximations for 1.8 and 2.2 gamma.

babl: add separate functions for 1.8 and 2.2 gamma

babl: optimize powf and its use in u8tou8 internal converter

babl: change how conversion computers (own) error

tools: babl-benchmark, print chosen paths

babl: include out own powf implementation

reduce set of default RGB spaces

extensions/gray: add const for rgbtoxyz matrix return

babl: only care about single precision for TRC

babl: make use of more direct trc dispatch in base

extensions: more direct trc dispatch

babl: speed up trc dispatch

By splitting the core computation done by the TRC down to callbacks of
different types, that all optionally can use the provided trc object.  This way
we can move the conditional for the polymorphism out of loops. The higher level
API of using the TRC still works - and is also accelerated by this change.

babl: silence cast warning

babl: add commented out u8 rgb to rgb converter

babl: register conversions between all RGB spaces

we register RGBA float and R'G'B'A float converters
between all spaces. This permits the converters between
precisions for each space to take effect.

babl: add single precision cmm matrices

babl: on demand clone sRGB conversions

When a new RGB space is encountered clone all sRGB space to sRGB space
conversions, under the assumption that they are implemented respecting/using
the customizable TRCs of babl.

extensions/CIE: use RGB space functions for xyz

extensions/gimp-8bit: use RGB space TRCs

extensions/float: use RGB space TRCs

extensions/cairo: use RGB space trc functions

babl/babl-format: add formats with custom RGB spaces to format db

tools/babl-benchmark: exclude conversions to self from average

The fast path the checks for source == dst, and replace with memcpy works,
including these memcpy aliases makes the barchart harder to read and the
average further from the median.

babl: move matrix code to new file babl-matrix.h

babl: remove unused babl_space_get_chromaticities

babl: make cache loading/parsing valgrind clean

babl: initialize used BablModel struct member data on init

babl: iterate on public space/icc API

babl-icc: length of string in descr should include \0

tools: Use rand when random is unavailable

borrowed from c1f075f22c70de54c2b04ca5df008a5e406d3ca9

babl-icc: detect 2.2 and 1.8 gammas LUTs

babl-icc: implement LUT TRC place holder code

babl-icc: detect sRGB LUT TRC and use babl's native sRGB TRC

Also add serialization of sRGB as an on-the fly generated 1024 element LUT.

babl-icc: implement reading and writing of LUTs for TRC

babl-icc: create struct for abstracting ICC file access

This also makes the ICC parsing re-entrant by getting rid of global variables.

tools: add a tool for testing icc profile writing